/**
 * 自动更新检查器
 * 负责管理自动更新检查的逻辑和状态
 */

import wgtHotUpdate from '../wgt-hot-update.js'
import settingsStorage from '../settings/storage.js'

class AutoUpdateChecker {
  constructor(config = {}) {
    // 默认配置
    const defaultConfig = {
      enabled: true,                          // 是否启用自动检查
      checkInterval: 24 * 60 * 60 * 1000,    // 检查间隔（24小时）
      timeout: 5000,                          // 请求超时（5秒）
      wifiOnly: false,                        // 是否仅WiFi检查
      silentFail: true,                       // 是否静默失败
      ...config
    }
    
    // 从设置存储读取配置
    const savedConfig = settingsStorage.load('update', null)
    
    // 合并配置：保存的设置 > 传入的配置 > 默认配置
    this.config = {
      ...defaultConfig,
      ...(savedConfig || {}),
      ...config
    }
    
    // 会话级别的忽略列表（应用重启后清空）
    this.sessionIgnoredVersions = new Set()
    
    console.log('[AutoUpdateChecker] 初始化完成，配置:', this.config)
  }
  
  /**
   * 执行更新检查（主入口）
   * @returns {Promise<CheckResult>} 检查结果
   */
  async checkForUpdate() {
    try {
      // 1. 检查是否启用
      if (!this.config.enabled) {
        console.log('[AutoUpdateChecker] 自动检查已禁用')
        return { hasUpdate: false, shouldShow: false }
      }
      
      // 2. 检查是否需要检查（基于时间间隔）
      if (!this.shouldCheck()) {
        console.log('[AutoUpdateChecker] 距离上次检查时间过短，跳过')
        return { hasUpdate: false, shouldShow: false }
      }
      
      // 3. 检查网络状态（如果配置了仅WiFi）
      if (this.config.wifiOnly) {
        const networkType = await this.getNetworkType()
        if (networkType !== 'wifi') {
          console.log('[AutoUpdateChecker] 非WiFi网络，跳过检查')
          return { hasUpdate: false, shouldShow: false }
        }
      }
      
      // 4. 确保Gitee配置已设置（如果未设置则使用默认配置）
      if (!wgtHotUpdate.giteeOwner || !wgtHotUpdate.giteeRepo) {
        console.log('[AutoUpdateChecker] Gitee配置未设置，使用默认配置')
        wgtHotUpdate.setGiteeConfig('xuxinzhi2206', 'moe_web', '')
      }
      
      // 5. 调用现有的更新检查API
      console.log('[AutoUpdateChecker] 开始检查更新...')
      const result = await wgtHotUpdate.checkForUpdate()
      
      // 6. 记录检查时间
      this.recordCheckTime()
      
      // 7. 记录更新日志
      this.logUpdateAction('check', {
        hasUpdate: result.hasUpdate,
        currentVersion: result.currentVersion,
        remoteVersion: result.remoteVersion,
        message: result.message
      })
      
      // 8. 判断是否应该显示横幅
      if (result.hasUpdate) {
        const shouldShow = !this.isVersionIgnoredInSession(result.remoteVersion)
        console.log('[AutoUpdateChecker] 发现新版本:', result.remoteVersion, '是否显示:', shouldShow)
        return {
          ...result,
          shouldShow: shouldShow
        }
      }
      
      console.log('[AutoUpdateChecker] 当前已是最新版本')
      return {
        ...result,
        shouldShow: false
      }
      
    } catch (error) {
      console.error('[AutoUpdateChecker] 检查更新失败:', error)
      
      // 记录失败日志
      this.logUpdateAction('check', {
        hasUpdate: false,
        error: error.message || '检查更新失败'
      })
      
      if (this.config.silentFail) {
        // 静默失败，不影响用户体验
        console.log('[AutoUpdateChecker] 静默失败，不显示错误')
        return { hasUpdate: false, shouldShow: false, error: error.message }
      } else {
        throw error
      }
    }
  }
  
  /**
   * 判断是否需要检查更新
   * @returns {Boolean} 是否需要检查
   */
  shouldCheck() {
    const lastCheckTime = this.getLastCheckTime()
    if (!lastCheckTime) {
      console.log('[AutoUpdateChecker] 首次检查')
      return true
    }
    
    const now = Date.now()
    const elapsed = now - lastCheckTime
    const shouldCheck = elapsed >= this.config.checkInterval
    
    console.log('[AutoUpdateChecker] 距离上次检查:', Math.floor(elapsed / 1000 / 60), '分钟，是否需要检查:', shouldCheck)
    
    return shouldCheck
  }
  
  /**
   * 记录检查时间
   */
  recordCheckTime() {
    try {
      const now = Date.now()
      uni.setStorageSync('auto_update_last_check', now)
      console.log('[AutoUpdateChecker] 记录检查时间:', new Date(now).toLocaleString())
    } catch (error) {
      console.error('[AutoUpdateChecker] 记录检查时间失败:', error)
    }
  }
  
  /**
   * 获取上次检查时间
   * @returns {Number} 时间戳
   */
  getLastCheckTime() {
    try {
      const lastCheck = uni.getStorageSync('auto_update_last_check') || 0
      if (lastCheck) {
        console.log('[AutoUpdateChecker] 上次检查时间:', new Date(lastCheck).toLocaleString())
      }
      return lastCheck
    } catch (error) {
      console.error('[AutoUpdateChecker] 获取上次检查时间失败:', error)
      return 0
    }
  }
  
  /**
   * 判断用户是否在当前会话中忽略了更新
   * @param {String} version - 版本号
   * @returns {Boolean}
   */
  isVersionIgnoredInSession(version) {
    const ignored = this.sessionIgnoredVersions.has(version)
    if (ignored) {
      console.log('[AutoUpdateChecker] 版本', version, '在当前会话中已被忽略')
    }
    return ignored
  }
  
  /**
   * 标记版本在当前会话中被忽略
   * @param {String} version - 版本号
   */
  ignoreVersionInSession(version) {
    this.sessionIgnoredVersions.add(version)
    console.log('[AutoUpdateChecker] 版本', version, '已标记为在当前会话中忽略')
  }
  
  /**
   * 清除会话忽略记录
   */
  clearSessionIgnores() {
    this.sessionIgnoredVersions.clear()
    console.log('[AutoUpdateChecker] 已清除所有会话忽略记录')
  }
  
  /**
   * 获取网络类型
   * @returns {Promise<String>} 网络类型
   */
  async getNetworkType() {
    return new Promise((resolve) => {
      uni.getNetworkType({
        success: (res) => {
          console.log('[AutoUpdateChecker] 当前网络类型:', res.networkType)
          resolve(res.networkType)
        },
        fail: () => {
          console.log('[AutoUpdateChecker] 获取网络类型失败，默认为unknown')
          resolve('unknown')
        }
      })
    })
  }
  
  /**
   * 记录更新日志
   * @param {String} action - 操作类型（check/upgrade/ignore/close）
   * @param {Object} data - 日志数据
   */
  logUpdateAction(action, data = {}) {
    try {
      const log = {
        action: action,
        timestamp: new Date().toISOString(),
        ...data
      }
      
      // 获取现有日志
      const logs = this.getUpdateLogs()
      logs.unshift(log)
      
      // 限制日志数量（最多保留50条）
      if (logs.length > 50) {
        logs.splice(50)
      }
      
      // 保存日志
      uni.setStorageSync('auto_update_logs', JSON.stringify(logs))
      console.log('[AutoUpdateChecker] 记录日志:', action, data)
    } catch (error) {
      console.error('[AutoUpdateChecker] 记录日志失败:', error)
    }
  }
  
  /**
   * 获取更新日志
   * @returns {Array} 日志列表
   */
  getUpdateLogs() {
    try {
      const logs = uni.getStorageSync('auto_update_logs')
      return logs ? JSON.parse(logs) : []
    } catch (error) {
      console.error('[AutoUpdateChecker] 获取日志失败:', error)
      return []
    }
  }
  
  /**
   * 清除更新日志
   */
  clearUpdateLogs() {
    try {
      uni.removeStorageSync('auto_update_logs')
      console.log('[AutoUpdateChecker] 已清除所有更新日志')
    } catch (error) {
      console.error('[AutoUpdateChecker] 清除日志失败:', error)
    }
  }
}

// 导出单例
export default new AutoUpdateChecker()
